// var a = (function () {
//     function t() {}
//     t.deepCopy = function (t) {
//         var o = new WeakMap();
//         var n = function (e) {
//             if (null === e) {
//                 return null;
//             }
//             var t = e.constructor;
//             switch (t) {
//                 case Array:
//                     return (function (e) {
//                         var t = [];
//                         o.set(e, t);
//                         e.forEach(function (e) {
//                             t.push(r(e));
//                         });
//                         return t;
//                     })(e);
//                 case Map:
//                     return (function (e) {
//                         var t = new Map();
//                         o.set(e, t);
//                         e.forEach(function (e, o) {
//                             t.set(o, r(e));
//                         });
//                         return t;
//                     })(e);
//                 case Set:
//                     return (function (e) {
//                         var t = new Set();
//                         o.set(e, t);
//                         e.forEach(function (e) {
//                             t.add(r(e));
//                         });
//                         return t;
//                     })(e);
//                 case Date:
//                 case Number:
//                 case String:
//                     return a(t, e);
//                 case Boolean:
//                     return a(t, e.valueOf());
//                 case RegExp:
//                     return (function (e) {
//                         var t = new RegExp(e.source, e.flags);
//                         t.lastIndex = e.lastIndex;
//                         return t;
//                     })(e);
//             }
//             var n = Object.create(Reflect.getPrototypeOf(e));
//             o.set(e, n);
//             var c = 0;
//             for (var s = Reflect.ownKeys(e); c < s.length; c++) {
//                 var l = s[c];
//                 var u = Reflect.getOwnPropertyDescriptor(e, l);
//                 var d = __assign({}, u);
//                 if ("value" in u) {
//                     d.value = r(e[l]);
//                 }
//                 Reflect.defineProperty(n, l, d);
//             }
//             return n;
//         };
//         var a = function (e, t) {
//             return new e(t);
//         };
//         var r = function (t) {
//             if ("object" != typeof t) {
//                 return t;
//             } else {
//                 return o.has(t) ? o.get(t) : n(t);
//             }
//         };
//         return r(t);
//     };
//     t.mapToObject = function (e) {
//         var t = {};
//         var o = Array.from(e.keys());
//         for (var n = 0; n < o.length; n++) {
//             var i = o[n];
//             t[i] = e.get(i);
//         }
//         return t;
//     };
//     t.objectToMap = function (e) {
//         var t = new Map();
//         if (!e) {
//             return t;
//         }
//         var o = Object.keys(e);
//         for (var n = 0; n < o.length; n++) {
//             var i = o[n];
//             t.set(i, e[i]);
//         }
//         return t;
//     };
//     t.diff = function (e, t) {
//         var o = {};
//         var n = Object.keys(e);
//         for (var i = 0; i < n.length; i++) {
//             var a = n[i];
//             if (e[a] !== t[a]) {
//                 o[a] = t[a];
//             }
//         }
//         return o;
//     };
//     return t;
// })();
// exports.default = a;



// /**
//  * 工具类，提供深拷贝、Map与Object互转、对象差异计算等功能
//  * 建议类名：Utility
//  */
// class ObjectUtils {
//     constructor() { }

//     /**
//      * 深拷贝一个对象
//      * @param source 要拷贝的对象
//      * @returns 拷贝后的新对象
//      * 建议方法名：deepClone
//      */
//     static deepCopy(source: any): any {
//         const weakMap = new WeakMap();

//         const clone = (value: any): any => {
//             if (value === null) {
//                 return null;
//             }

//             const constructor = value.constructor;
//             switch (constructor) {
//                 case Array:
//                     return (function (arr: any[]) {
//                         const result: any[] = [];
//                         weakMap.set(arr, result);
//                         arr.forEach(item => {
//                             result.push(deepClone(item));
//                         });
//                         return result;
//                     })(value);
//                 case Map:
//                     return (function (map: Map<any, any>) {
//                         const result = new Map();
//                         weakMap.set(map, result);
//                         map.forEach((val, key) => {
//                             result.set(key, deepClone(val));
//                         });
//                         return result;
//                     })(value);
//                 case Set:
//                     return (function (set: Set<any>) {
//                         const result = new Set();
//                         weakMap.set(set, result);
//                         set.forEach(item => {
//                             result.add(deepClone(item));
//                         });
//                         return result;
//                     })(value);
//                 case Date:
//                 case Number:
//                 case String:
//                     return new constructor(value);
//                 case Boolean:
//                     return new constructor(value.valueOf());
//                 case RegExp:
//                     return (function (regex: RegExp) {
//                         const result = new RegExp(regex.source, regex.flags);
//                         result.lastIndex = regex.lastIndex;
//                         return result;
//                     })(value);
//             }

//             const proto = Object.create(Reflect.getPrototypeOf(value));
//             weakMap.set(value, proto);
//             const keys = Reflect.ownKeys(value);
//             keys.forEach(key => {
//                 const descriptor = Reflect.getOwnPropertyDescriptor(value, key);
//                 if (descriptor) {
//                     const newDescriptor = { ...descriptor };
//                     if ('value' in descriptor) {
//                         newDescriptor.value = deepClone(value[key]);
//                     }
//                     Reflect.defineProperty(proto, key, newDescriptor);
//                 }
//             });
//             return proto;
//         };

//         const deepClone = (obj: any): any => {
//             if (typeof obj !== 'object') {
//                 return obj;
//             } else {
//                 return weakMap.has(obj) ? weakMap.get(obj) : clone(obj);
//             }
//         };

//         return deepClone(source);
//     }

//     /**
//      * 将Map转换为Object
//      * @param map 要转换的Map
//      * @returns 转换后的Object
//      * 建议方法名：mapToObj
//      */
//     static mapToObject(map: Map<any, any>): { [key: string]: any } {
//         const obj: { [key: string]: any } = {};
//         const keys = Array.from(map.keys());
//         keys.forEach(key => {
//             obj[key] = map.get(key);
//         });
//         return obj;
//     }

//     /**
//      * 将Object转换为Map
//      * @param obj 要转换的Object
//      * @returns 转换后的Map
//      * 建议方法名：objToMap
//      */
//     static objectToMap(obj: { [key: string]: any }): Map<any, any> {
//         const map = new Map();
//         if (!obj) {
//             return map;
//         }
//         const keys = Object.keys(obj);
//         keys.forEach(key => {
//             map.set(key, obj[key]);
//         });
//         return map;
//     }

//     /**
//      * 计算两个对象的差异
//      * @param obj1 对象1
//      * @param obj2 对象2
//      * @returns 包含差异的对象
//      * 建议方法名：calculateDiff
//      */
//     static diff(obj1: { [key: string]: any }, obj2: { [key: string]: any }): { [key: string]: any } {
//         const diffObj: { [key: string]: any } = {};
//         const keys = Object.keys(obj1);
//         keys.forEach(key => {
//             if (obj1[key] !== obj2[key]) {
//                 diffObj[key] = obj2[key];
//             }
//         });
//         return diffObj;
//     }
// }

// export default ObjectUtils;

/**
 * 工具类，提供深拷贝、Map与Object互转、对象差异计算等功能
 * 建议类名：Utility
 */
class ObjectUtils {
    constructor() { }

    /**
     * 深拷贝一个对象
     * 建议方法名：deepClone
     * @param source 要拷贝的对象
     * @returns 拷贝后的新对象
     */
    static deepClone(source: any): any {
        const weakMap = new WeakMap();

        const clone = (value: any): any => {
            if (value === null) return null;

            const constructor = value.constructor;
            switch (constructor) {
                case Array:
                    return (function (arr: any[]) {
                        const result: any[] = [];
                        weakMap.set(arr, result);
                        arr.forEach(item => result.push(deepClone(item)));
                        return result;
                    })(value);
                case Map:
                    return (function (map: Map<any, any>) {
                        const result = new Map();
                        weakMap.set(map, result);
                        map.forEach((val, key) => result.set(key, deepClone(val)));
                        return result;
                    })(value);
                case Set:
                    return (function (set: Set<any>) {
                        const result = new Set();
                        weakMap.set(set, result);
                        set.forEach(item => result.add(deepClone(item)));
                        return result;
                    })(value);
                case Date:
                case Number:
                case String:
                    return new constructor(value);
                case Boolean:
                    return new constructor(value.valueOf());
                case RegExp:
                    return (function (regex: RegExp) {
                        const result = new RegExp(regex.source, regex.flags);
                        result.lastIndex = regex.lastIndex;
                        return result;
                    })(value);
                default:
                    break;
            }

            const proto = Object.create(Object.getPrototypeOf(value));
            weakMap.set(value, proto);
            Reflect.ownKeys(value).forEach(key => {
                const descriptor = Reflect.getOwnPropertyDescriptor(value, key);
                if (descriptor) {
                    const newDescriptor = { ...descriptor };
                    if ('value' in descriptor) {
                        newDescriptor.value = deepClone(value[key]);
                    }
                    Reflect.defineProperty(proto, key, newDescriptor);
                }
            });
            return proto;
        };

        const deepClone = (obj: any): any => {
            if (typeof obj !== 'object' || obj === null) {
                return obj;
            } else {
                return weakMap.has(obj) ? weakMap.get(obj) : clone(obj);
            }
        };

        return deepClone(source);
    }

    /**
     * 将Map转换为Object
     * 建议方法名：mapToObj
     * @param map 要转换的Map
     * @returns 转换后的Object
     */
    static mapToObj(map: Map<any, any>): { [key: string]: any } {
        const result: { [key: string]: any } = {};
        map.forEach((value, key) => {
            result[key] = value;
        });
        return result;
    }

    /**
     * 将Object转换为Map
     * 建议方法名：objToMap
     * @param obj 要转换的Object
     * @returns 转换后的Map
     */
    static objToMap(obj: { [key: string]: any }): Map<any, any> {
        const map = new Map();
        Object.keys(obj || {}).forEach(key => {
            map.set(key, obj[key]);
        });
        return map;
    }

    /**
     * 计算两个对象的差异
     * 建议方法名：calculateDiff
     * @param object1 对象1
     * @param object2 对象2
     * @returns 包含差异的对象
     */
    static calculateDiff(object1: { [key: string]: any }, object2: { [key: string]: any }): { [key: string]: any } {
        const diffResult: { [key: string]: any } = {};
        Object.keys(object1).forEach(key => {
            if (object1[key] !== object2[key]) {
                diffResult[key] = object2[key];
            }
        });
        return diffResult;
    }
}

export default ObjectUtils;